{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.116000; val_acc: 0.094000\n",
      "(Iteration 101 / 4900) loss: 1.829613\n",
      "(Iteration 201 / 4900) loss: 1.857390\n",
      "(Iteration 301 / 4900) loss: 1.744448\n",
      "(Iteration 401 / 4900) loss: 1.420187\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.422000\n",
      "(Iteration 501 / 4900) loss: 1.565913\n",
      "(Iteration 601 / 4900) loss: 1.700510\n",
      "(Iteration 701 / 4900) loss: 1.732213\n",
      "(Iteration 801 / 4900) loss: 1.688361\n",
      "(Iteration 901 / 4900) loss: 1.439529\n",
      "(Epoch 2 / 10) train acc: 0.497000; val_acc: 0.468000\n",
      "(Iteration 1001 / 4900) loss: 1.385772\n",
      "(Iteration 1101 / 4900) loss: 1.278401\n",
      "(Iteration 1201 / 4900) loss: 1.641580\n",
      "(Iteration 1301 / 4900) loss: 1.438847\n",
      "(Iteration 1401 / 4900) loss: 1.172536\n",
      "(Epoch 3 / 10) train acc: 0.490000; val_acc: 0.466000\n",
      "(Iteration 1501 / 4900) loss: 1.346286\n",
      "(Iteration 1601 / 4900) loss: 1.268492\n",
      "(Iteration 1701 / 4900) loss: 1.318215\n",
      "(Iteration 1801 / 4900) loss: 1.395750\n",
      "(Iteration 1901 / 4900) loss: 1.338233\n",
      "(Epoch 4 / 10) train acc: 0.532000; val_acc: 0.497000\n",
      "(Iteration 2001 / 4900) loss: 1.343165\n",
      "(Iteration 2101 / 4900) loss: 1.393173\n",
      "(Iteration 2201 / 4900) loss: 1.276734\n",
      "(Iteration 2301 / 4900) loss: 1.287951\n",
      "(Iteration 2401 / 4900) loss: 1.352778\n",
      "(Epoch 5 / 10) train acc: 0.525000; val_acc: 0.475000\n",
      "(Iteration 2501 / 4900) loss: 1.390234\n",
      "(Iteration 2601 / 4900) loss: 1.276361\n",
      "(Iteration 2701 / 4900) loss: 1.111768\n",
      "(Iteration 2801 / 4900) loss: 1.271688\n",
      "(Iteration 2901 / 4900) loss: 1.272039\n",
      "(Epoch 6 / 10) train acc: 0.546000; val_acc: 0.509000\n",
      "(Iteration 3001 / 4900) loss: 1.304489\n",
      "(Iteration 3101 / 4900) loss: 1.346667\n",
      "(Iteration 3201 / 4900) loss: 1.325510\n",
      "(Iteration 3301 / 4900) loss: 1.392728\n",
      "(Iteration 3401 / 4900) loss: 1.402001\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 3501 / 4900) loss: 1.319024\n",
      "(Iteration 3601 / 4900) loss: 1.153287\n",
      "(Iteration 3701 / 4900) loss: 1.180922\n",
      "(Iteration 3801 / 4900) loss: 1.093164\n",
      "(Iteration 3901 / 4900) loss: 1.135902\n",
      "(Epoch 8 / 10) train acc: 0.568000; val_acc: 0.490000\n",
      "(Iteration 4001 / 4900) loss: 1.191735\n",
      "(Iteration 4101 / 4900) loss: 1.359396\n",
      "(Iteration 4201 / 4900) loss: 1.227283\n",
      "(Iteration 4301 / 4900) loss: 1.024113\n",
      "(Iteration 4401 / 4900) loss: 1.327583\n",
      "(Epoch 9 / 10) train acc: 0.592000; val_acc: 0.504000\n",
      "(Iteration 4501 / 4900) loss: 0.963330\n",
      "(Iteration 4601 / 4900) loss: 1.445619\n",
      "(Iteration 4701 / 4900) loss: 1.007542\n",
      "(Iteration 4801 / 4900) loss: 1.005175\n",
      "(Epoch 10 / 10) train acc: 0.611000; val_acc: 0.512000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data, update_rule='sgd', \n",
    "                optim_config={'learning_rate':1e-3,}, \n",
    "                lr_decay=0.95, num_epochs=10, \n",
    "                batch_size=100, print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 6.86e-09\n",
      "W2 relative error: 3.52e-08\n",
      "W3 relative error: 1.32e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 357.428290\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.111000\n",
      "(Epoch 1 / 20) train acc: 0.380000; val_acc: 0.141000\n",
      "(Epoch 2 / 20) train acc: 0.520000; val_acc: 0.138000\n",
      "(Epoch 3 / 20) train acc: 0.740000; val_acc: 0.130000\n",
      "(Epoch 4 / 20) train acc: 0.820000; val_acc: 0.153000\n",
      "(Epoch 5 / 20) train acc: 0.860000; val_acc: 0.175000\n",
      "(Iteration 11 / 40) loss: 6.726589\n",
      "(Epoch 6 / 20) train acc: 0.940000; val_acc: 0.163000\n",
      "(Epoch 7 / 20) train acc: 0.960000; val_acc: 0.166000\n",
      "(Epoch 8 / 20) train acc: 0.960000; val_acc: 0.164000\n",
      "(Epoch 9 / 20) train acc: 0.980000; val_acc: 0.162000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.162000\n",
      "(Iteration 21 / 40) loss: 0.800243\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Iteration 31 / 40) loss: 0.000000\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.158000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "learning_rate = 1e-3  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 166.501707\n",
      "(Epoch 0 / 20) train acc: 0.100000; val_acc: 0.107000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.101000\n",
      "(Epoch 2 / 20) train acc: 0.160000; val_acc: 0.122000\n",
      "(Epoch 3 / 20) train acc: 0.380000; val_acc: 0.106000\n",
      "(Epoch 4 / 20) train acc: 0.520000; val_acc: 0.111000\n",
      "(Epoch 5 / 20) train acc: 0.760000; val_acc: 0.113000\n",
      "(Iteration 11 / 40) loss: 3.343141\n",
      "(Epoch 6 / 20) train acc: 0.840000; val_acc: 0.122000\n",
      "(Epoch 7 / 20) train acc: 0.920000; val_acc: 0.113000\n",
      "(Epoch 8 / 20) train acc: 0.940000; val_acc: 0.125000\n",
      "(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.125000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.121000\n",
      "(Iteration 21 / 40) loss: 0.039138\n",
      "(Epoch 11 / 20) train acc: 0.980000; val_acc: 0.123000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Iteration 31 / 40) loss: 0.000644\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.121000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.121000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-3  # Experiment with this!\n",
    "weight_scale = 1e-1   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.559978\n",
      "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.107000\n",
      "(Iteration 11 / 200) loss: 2.356069\n",
      "(Iteration 21 / 200) loss: 2.214091\n",
      "(Iteration 31 / 200) loss: 2.205928\n",
      "(Epoch 1 / 5) train acc: 0.225000; val_acc: 0.193000\n",
      "(Iteration 41 / 200) loss: 2.132095\n",
      "(Iteration 51 / 200) loss: 2.118950\n",
      "(Iteration 61 / 200) loss: 2.116443\n",
      "(Iteration 71 / 200) loss: 2.132549\n",
      "(Epoch 2 / 5) train acc: 0.298000; val_acc: 0.260000\n",
      "(Iteration 81 / 200) loss: 1.977227\n",
      "(Iteration 91 / 200) loss: 2.007528\n",
      "(Iteration 101 / 200) loss: 2.004762\n",
      "(Iteration 111 / 200) loss: 1.885342\n",
      "(Epoch 3 / 5) train acc: 0.343000; val_acc: 0.287000\n",
      "(Iteration 121 / 200) loss: 1.891517\n",
      "(Iteration 131 / 200) loss: 1.923677\n",
      "(Iteration 141 / 200) loss: 1.957744\n",
      "(Iteration 151 / 200) loss: 1.966736\n",
      "(Epoch 4 / 5) train acc: 0.322000; val_acc: 0.305000\n",
      "(Iteration 161 / 200) loss: 1.801483\n",
      "(Iteration 171 / 200) loss: 1.973779\n",
      "(Iteration 181 / 200) loss: 1.666573\n",
      "(Iteration 191 / 200) loss: 1.909494\n",
      "(Epoch 5 / 5) train acc: 0.372000; val_acc: 0.319000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.153777\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.088000\n",
      "(Iteration 11 / 200) loss: 2.227203\n",
      "(Iteration 21 / 200) loss: 2.125706\n",
      "(Iteration 31 / 200) loss: 1.932679\n",
      "(Epoch 1 / 5) train acc: 0.308000; val_acc: 0.258000\n",
      "(Iteration 41 / 200) loss: 1.946329\n",
      "(Iteration 51 / 200) loss: 1.780464\n",
      "(Iteration 61 / 200) loss: 1.753503\n",
      "(Iteration 71 / 200) loss: 1.844626\n",
      "(Epoch 2 / 5) train acc: 0.377000; val_acc: 0.331000\n",
      "(Iteration 81 / 200) loss: 2.028390\n",
      "(Iteration 91 / 200) loss: 1.685415\n",
      "(Iteration 101 / 200) loss: 1.513205\n",
      "(Iteration 111 / 200) loss: 1.431671\n",
      "(Epoch 3 / 5) train acc: 0.469000; val_acc: 0.335000\n",
      "(Iteration 121 / 200) loss: 1.678510\n",
      "(Iteration 131 / 200) loss: 1.544807\n",
      "(Iteration 141 / 200) loss: 1.620010\n",
      "(Iteration 151 / 200) loss: 1.691080\n",
      "(Epoch 4 / 5) train acc: 0.483000; val_acc: 0.356000\n",
      "(Iteration 161 / 200) loss: 1.474017\n",
      "(Iteration 171 / 200) loss: 1.374763\n",
      "(Iteration 181 / 200) loss: 1.350303\n",
      "(Iteration 191 / 200) loss: 1.376466\n",
      "(Epoch 5 / 5) train acc: 0.509000; val_acc: 0.348000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lsm/miniconda3/envs/cs231n/lib/python3.7/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.476928\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.027712\n",
      "(Iteration 21 / 200) loss: 2.183358\n",
      "(Iteration 31 / 200) loss: 1.744257\n",
      "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
      "(Iteration 41 / 200) loss: 1.707951\n",
      "(Iteration 51 / 200) loss: 1.703835\n",
      "(Iteration 61 / 200) loss: 2.094758\n",
      "(Iteration 71 / 200) loss: 1.505514\n",
      "(Epoch 2 / 5) train acc: 0.416000; val_acc: 0.362000\n",
      "(Iteration 81 / 200) loss: 1.594391\n",
      "(Iteration 91 / 200) loss: 1.483393\n",
      "(Iteration 101 / 200) loss: 1.391985\n",
      "(Iteration 111 / 200) loss: 1.410419\n",
      "(Epoch 3 / 5) train acc: 0.496000; val_acc: 0.374000\n",
      "(Iteration 121 / 200) loss: 1.190327\n",
      "(Iteration 131 / 200) loss: 1.446230\n",
      "(Iteration 141 / 200) loss: 1.358681\n",
      "(Iteration 151 / 200) loss: 1.324699\n",
      "(Epoch 4 / 5) train acc: 0.512000; val_acc: 0.345000\n",
      "(Iteration 161 / 200) loss: 1.411794\n",
      "(Iteration 171 / 200) loss: 1.208069\n",
      "(Iteration 181 / 200) loss: 1.174987\n",
      "(Iteration 191 / 200) loss: 1.255647\n",
      "(Epoch 5 / 5) train acc: 0.554000; val_acc: 0.382000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.589166\n",
      "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
      "(Iteration 11 / 200) loss: 2.039570\n",
      "(Iteration 21 / 200) loss: 1.897350\n",
      "(Iteration 31 / 200) loss: 1.763822\n",
      "(Epoch 1 / 5) train acc: 0.385000; val_acc: 0.314000\n",
      "(Iteration 41 / 200) loss: 1.891118\n",
      "(Iteration 51 / 200) loss: 1.703039\n",
      "(Iteration 61 / 200) loss: 1.477016\n",
      "(Iteration 71 / 200) loss: 1.596357\n",
      "(Epoch 2 / 5) train acc: 0.426000; val_acc: 0.346000\n",
      "(Iteration 81 / 200) loss: 1.512986\n",
      "(Iteration 91 / 200) loss: 1.617882\n",
      "(Iteration 101 / 200) loss: 1.501945\n",
      "(Iteration 111 / 200) loss: 1.560044\n",
      "(Epoch 3 / 5) train acc: 0.468000; val_acc: 0.367000\n",
      "(Iteration 121 / 200) loss: 1.506940\n",
      "(Iteration 131 / 200) loss: 1.541989\n",
      "(Iteration 141 / 200) loss: 1.527032\n",
      "(Iteration 151 / 200) loss: 1.697893\n",
      "(Epoch 4 / 5) train acc: 0.517000; val_acc: 0.364000\n",
      "(Iteration 161 / 200) loss: 1.579252\n",
      "(Iteration 171 / 200) loss: 1.440867\n",
      "(Iteration 181 / 200) loss: 1.507251\n",
      "(Iteration 191 / 200) loss: 1.368954\n",
      "(Epoch 5 / 5) train acc: 0.538000; val_acc: 0.364000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight_scales = 0.050000, learning_rates = 0.001000, batch_sizes = 200.000000\n",
      "(Iteration 1 / 7350) loss: 34.134130\n",
      "(Epoch 0 / 30) train acc: 0.119000; val_acc: 0.106000\n",
      "(Epoch 1 / 30) train acc: 0.395000; val_acc: 0.403000\n",
      "(Epoch 2 / 30) train acc: 0.405000; val_acc: 0.412000\n",
      "(Iteration 501 / 7350) loss: 1.952197\n",
      "(Epoch 3 / 30) train acc: 0.421000; val_acc: 0.418000\n",
      "(Epoch 4 / 30) train acc: 0.388000; val_acc: 0.395000\n",
      "(Iteration 1001 / 7350) loss: 1.863019\n",
      "(Epoch 5 / 30) train acc: 0.417000; val_acc: 0.424000\n",
      "(Epoch 6 / 30) train acc: 0.459000; val_acc: 0.439000\n",
      "(Iteration 1501 / 7350) loss: 1.850156\n",
      "(Epoch 7 / 30) train acc: 0.491000; val_acc: 0.474000\n",
      "(Epoch 8 / 30) train acc: 0.461000; val_acc: 0.467000\n",
      "(Iteration 2001 / 7350) loss: 1.832677\n",
      "(Epoch 9 / 30) train acc: 0.484000; val_acc: 0.457000\n",
      "(Epoch 10 / 30) train acc: 0.513000; val_acc: 0.479000\n",
      "(Iteration 2501 / 7350) loss: 1.689661\n",
      "(Epoch 11 / 30) train acc: 0.500000; val_acc: 0.433000\n",
      "(Epoch 12 / 30) train acc: 0.491000; val_acc: 0.499000\n",
      "(Iteration 3001 / 7350) loss: 1.559009\n",
      "(Epoch 13 / 30) train acc: 0.538000; val_acc: 0.487000\n",
      "(Epoch 14 / 30) train acc: 0.540000; val_acc: 0.497000\n",
      "(Iteration 3501 / 7350) loss: 1.405206\n",
      "(Epoch 15 / 30) train acc: 0.517000; val_acc: 0.513000\n",
      "(Epoch 16 / 30) train acc: 0.553000; val_acc: 0.504000\n",
      "(Iteration 4001 / 7350) loss: 1.579744\n",
      "(Epoch 17 / 30) train acc: 0.530000; val_acc: 0.530000\n",
      "(Epoch 18 / 30) train acc: 0.573000; val_acc: 0.503000\n",
      "(Iteration 4501 / 7350) loss: 1.421924\n",
      "(Epoch 19 / 30) train acc: 0.590000; val_acc: 0.543000\n",
      "(Epoch 20 / 30) train acc: 0.628000; val_acc: 0.551000\n",
      "(Iteration 5001 / 7350) loss: 1.375287\n",
      "(Epoch 21 / 30) train acc: 0.589000; val_acc: 0.534000\n",
      "(Epoch 22 / 30) train acc: 0.611000; val_acc: 0.545000\n",
      "(Iteration 5501 / 7350) loss: 1.500031\n",
      "(Epoch 23 / 30) train acc: 0.612000; val_acc: 0.532000\n",
      "(Epoch 24 / 30) train acc: 0.650000; val_acc: 0.548000\n",
      "(Iteration 6001 / 7350) loss: 1.215648\n",
      "(Epoch 25 / 30) train acc: 0.639000; val_acc: 0.545000\n",
      "(Epoch 26 / 30) train acc: 0.637000; val_acc: 0.543000\n",
      "(Iteration 6501 / 7350) loss: 1.236738\n",
      "(Epoch 27 / 30) train acc: 0.671000; val_acc: 0.536000\n",
      "(Epoch 28 / 30) train acc: 0.643000; val_acc: 0.557000\n",
      "(Iteration 7001 / 7350) loss: 1.210165\n",
      "(Epoch 29 / 30) train acc: 0.706000; val_acc: 0.540000\n",
      "(Epoch 30 / 30) train acc: 0.691000; val_acc: 0.542000\n",
      "val_acc = 0.529000\n",
      "=========================================================================\n",
      "Training took 0 hours 25 minutes 24 seconds\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "best_val = -1\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# Check train and val accuracy on the first iteration, the last\n",
    "# iteration, and at the end of each epoch.\n",
    "# Append loss(not train or val loss) per iteration\n",
    "import time\n",
    "tic = time.time()\n",
    "\n",
    "X_val= data['X_val']\n",
    "y_val= data['y_val']\n",
    "X_test= data['X_test']\n",
    "y_test= data['y_test']\n",
    "\n",
    "regularization_strength = 1e-2\n",
    "# weight_scales = [2.5e-2, 5e-2]\n",
    "# learning_rates = [1e-3, 3e-3, 1e-2]\n",
    "# batch_sizes = [100]\n",
    "weight_scales = [5e-2]\n",
    "learning_rates = [1e-3]\n",
    "batch_sizes = [200]\n",
    "for ws in weight_scales:\n",
    "    for lr in learning_rates:\n",
    "        for bs in batch_sizes:\n",
    "            model = FullyConnectedNet([600, 500, 400, 300, 200, 100],\n",
    "                                     weight_scale=ws,\n",
    "                                     reg = regularization_strength, dtype=np.float64,\n",
    "                                     dropout=1, normalization='batchnorm')\n",
    "            \n",
    "            solver = Solver(model, data,\n",
    "                print_every=500, num_epochs=30, batch_size=bs,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': lr,\n",
    "                },\n",
    "                lr_decay=0.95) # decay learning rate when epoch increase 1\n",
    "            print('weight_scales = %f, learning_rates = %f, batch_sizes = %f' % (ws, lr, bs))\n",
    "            solver.train()\n",
    "            y_val_pred = np.argmax(model.loss(X_val), axis=1)\n",
    "            val_acc = (y_val_pred == y_val).mean()\n",
    "            print('val_acc = %f' % (val_acc))\n",
    "            print('=========================================================================')\n",
    "            if val_acc > best_val:\n",
    "                best_val = val_acc\n",
    "                best_model = model\n",
    "\n",
    "toc = time.time()\n",
    "total_seconds = int(toc - tic)\n",
    "hours = total_seconds // 3600\n",
    "minutes = (total_seconds - hours * 3600) // 60\n",
    "seconds = total_seconds - hours * 3600 - minutes * 60\n",
    "print('Training took %d hours %d minutes %d seconds' % (hours, minutes, seconds))\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.529\n",
      "Test set accuracy:  0.528\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(solver.loss_history)\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(solver.train_acc_history, label='train')\n",
    "plt.plot(solver.val_acc_history, label='val')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Clasification accuracy')\n",
    "plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
